home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / eddilib / bitmap2.c < prev    next >
C/C++ Source or Header  |  1993-04-29  |  5KB  |  204 lines
  1. /*********************************************************/
  2. /*                                                                             */
  3. /*                              Demo-Quelltext fr                        */
  4. /*                    die Bearbeitung einer monochromen            */
  5. /*                             Off-Screen-Bitmap                        */
  6. /*                                                                            */
  7. /*********************************************************/
  8. /* sb */
  9. /* 28.04.93 */
  10.  
  11. /* Includes */
  12. #include <portab.h>
  13. #include <vdi.h>
  14. #include <aes.h>
  15. #include <tos.h>
  16. #include <eddilib.h>
  17.  
  18. /* Funktionsprototypen */
  19. WORD    open_vwk( WORD *work_out );
  20. WORD    open_bitmap( WORD x, WORD y, MFDB *bitmap, WORD *work_out );
  21. void    clip_screen( void );        
  22. void    clip_bitmap( void );        
  23. void    draw( void );
  24.  
  25. /* Globale Variablen */
  26. WORD  s_handle,
  27.         b_handle,
  28.         screen_out[128],
  29.         bitmap_out[128];
  30. MFDB    bitmap,
  31.         screen;
  32.  
  33. /* virtuelle Workstation ”ffnen */
  34. WORD    open_vwk( WORD *work_out )
  35. {
  36.     WORD    count,
  37.             dummy,
  38.             handle,
  39.             work_in[11];
  40.  
  41.     handle = graf_handle( &dummy, &dummy, &dummy, &dummy );
  42.  
  43.     for( count = 1; count < 10; count++ )
  44.         work_in[count] = 1;
  45.  
  46.     work_in[0] = Getrez()+2; 
  47.     work_in[10] = 2;                                /* Rasterkoordinaten */
  48.  
  49.     v_opnvwk( work_in, &handle, work_out );
  50.  
  51.     return( handle );
  52. }
  53.  
  54. /* Off-Screen-Bitmap ”ffnen */
  55. WORD    open_bitmap( WORD x, WORD y, MFDB *bitmap, WORD *work_out )
  56. {
  57.     WORD    count,
  58.             dummy,
  59.             handle,
  60.             work_in[20];
  61.  
  62.     handle = graf_handle( &dummy, &dummy, &dummy, &dummy );
  63.  
  64.     for( count = 1; count < 10; count++ )
  65.         work_in[count] = 1;
  66.  
  67.     work_in[0] = Getrez()+2; 
  68.     work_in[10] = 2;                                /* Rasterkoordinaten */
  69.     work_in[11] = x;                                /* Breite - 1 */
  70.     work_in[12] = y;                                /* H”he - 1 */
  71.     work_in[13] = work_in[14] = 0;            /* Pixelbreite und -H”he des Bildschirms bernehmen */
  72.     
  73.     for ( count = 15; count < 20; count++ )
  74.         work_in[count] = 0;                        /* reserviert */
  75.  
  76.     v_opnbm( work_in, bitmap, &handle, work_out );
  77.  
  78.     return( handle );
  79. }
  80.  
  81. /* Clipping fr den Bildschirm setzen */
  82. void    clip_screen( void )        
  83. {
  84.     WORD    xyarr[4];
  85.     
  86.     xyarr[0] = 0;
  87.     xyarr[1] = 0;
  88.     xyarr[2] = screen_out[0];
  89.     xyarr[3] = screen_out[1];
  90.     vs_clip( s_handle, 1, xyarr );    /* Clipping fr den Bildschirm */
  91. }
  92.  
  93. /* Clipping fr die Bitmap setzen */
  94. void    clip_bitmap( void )        
  95. {
  96.     WORD    xyarr[4];
  97.     
  98.     xyarr[0] = 0;
  99.     xyarr[1] = 0;
  100.     xyarr[2] = bitmap_out[0];
  101.     xyarr[3] = bitmap_out[1];
  102.     vs_clip( b_handle, 1, xyarr );    /* Clipping fr den Bildschirm */
  103. }
  104.  
  105. /* Auf der Off-Screen-Bitmap zeichnen */
  106. void    draw( void )
  107. {
  108.     BYTE    bezarr[512];
  109.     WORD    xyarr[512],
  110.             extent[4],
  111.             actual,
  112.             totpts,
  113.             totmoves;
  114.  
  115.     vsf_color( b_handle, 1 );
  116.     vsf_interior( b_handle, 2 ); 
  117.     vsf_style( b_handle, 1 );
  118.     vsf_perimeter( b_handle, 1 );
  119.     vswr_mode( b_handle, 1 );
  120.     
  121.     xyarr[0] = 0;
  122.     xyarr[1] = 0;
  123.     xyarr[2] = 250;
  124.     xyarr[3] = 250;
  125.     v_bar( b_handle, xyarr );
  126.     
  127.     vsf_style( b_handle, 3 );
  128.     v_bez_on( b_handle );
  129.     v_bez_qual( b_handle, 100, &actual );
  130.     
  131.     xyarr[0] = 100;
  132.     xyarr[1] = 100;
  133.     xyarr[2] = 400;
  134.     xyarr[3] = 100;
  135.     xyarr[4] = 400;
  136.     xyarr[5] = 400;
  137.     xyarr[6] = 100;
  138.     xyarr[7] = 400;
  139.     
  140.     xyarr[8] = 200;
  141.     xyarr[9] = 200;
  142.     xyarr[10] = 300;
  143.     xyarr[11] = 200;
  144.     xyarr[12] = 300;
  145.     xyarr[13] = 300;
  146.     xyarr[14] = 200;
  147.     xyarr[15] = 300;
  148.  
  149.     bezarr[0] = 1;
  150.     bezarr[1] = 0;
  151.     bezarr[2] = 0;
  152.     bezarr[3] = 0;
  153.     bezarr[4] = 3;
  154.     bezarr[5] = 0;
  155.     bezarr[6] = 0;
  156.     bezarr[7] = 0;
  157.     
  158.     _v_bez_fill( b_handle, 8, xyarr, bezarr, extent, &totpts, &totmoves );
  159.     v_bez_off( b_handle );
  160.  
  161.     v_gtext( b_handle, 50, 50, "monochromer Text!" );
  162.  
  163. }
  164.  
  165. main()
  166. {
  167.     WORD    xyarr[8];
  168.     WORD    fgbg[2];
  169.         
  170.     if (( s_handle = open_vwk( screen_out )) != 0 )
  171.     {
  172.         bitmap.fd_addr = 0;                        /* VDI alloziert Bitmap */
  173.         bitmap.fd_nplanes = 1;                    /* monochrome Bitmap */
  174.         if (( b_handle = open_bitmap( 799, 607, &bitmap, bitmap_out)) != 0 )
  175.         {
  176.             clip_screen();                            /* Clipping fr den Bildschirm setzen */
  177.             clip_bitmap();                            /* Clipping fr die Bitmap setzen */
  178.             draw();                                    /* auf der Off-Screen-Bitmap zeichnen */
  179.  
  180.             /* und jetzt die Bitmap auf den Bildschirm kopieren... */
  181.             screen.fd_addr = 0;
  182.             xyarr[0] = 0;
  183.             xyarr[1] = 0;
  184.             xyarr[2] = 799;
  185.             xyarr[3] = 607;
  186.             xyarr[4] = 100;
  187.             xyarr[5] = 100;
  188.             xyarr[6] = 899;
  189.             xyarr[7] = 707;
  190.             fgbg[0] = 6;
  191.             fgbg[1] = 2;
  192.             if ( screen_out[13] == 2 ) /* nur 2 Farben ? */
  193.             {
  194.                 fgbg[0] = 0; /* invertierte Ausgabe */
  195.                 fgbg[1] = 1;
  196.             }
  197.             vrt_cpyfm( s_handle, MD_REPLACE, xyarr, &bitmap, &screen, fgbg );
  198.     
  199.             v_clsbm( b_handle );                    /* Bitmap schliežen */
  200.         }
  201.         v_clsvwk( s_handle );                    /* virtuelle Workstation schliežen */
  202.     } 
  203.     return(0);    
  204. }